Course Survey — Grouped Likert plots

Author

Auto-generated R Markdown

Published

2025-12-27

Below is an updated R Markdown file that groups all Likert-type (ordered factor) columns together into combined stacked bar plots. It groups Likert columns that share the same set/ordering of levels (e.g., Agree scale vs Helpfulness scale) and produces one horizontal proportional stacked bar chart per group showing each question as a stacked bar (percentages by response). Non-Likert columns are still shown individually (numeric => histogram+boxplot, unordered factor => bar).

Save as survey_plots_likert_grouped.Rmd (in the same folder as course_survey_responses.csv) and knit or render.

Introduction

This document reads course_survey_responses.csv, coerces Likert-like columns to ordered factors, and:

  • groups Likert (ordered) questions that share the same set of levels into combined proportional stacked bar plots (one chart per group),
  • renders other variables individually (numeric -> histogram + boxplot; unordered factor -> bar).

Place course_survey_responses.csv in the same directory as this .Rmd (or change the data_file path below).

Setup: packages

R code
if (!requireNamespace("pacman", quietly = TRUE)) install.packages("pacman")
pacman::p_load(tidyverse, janitor, forcats, scales, ggthemes)

# patchwork is optional for numeric combined plots
if (!requireNamespace("patchwork", quietly = TRUE)) {
  message("To get combined histogram+boxplot layout install.packages('patchwork')")
}

Read data and preview

R code
data_file <- "../data/survey/course_survey_responses.csv"

df_raw <- readr::read_csv(data_file, locale = readr::locale(encoding = "UTF-8"), na = c("", "NA"))
# Keep a cleaned-names version for programming but preserve original names for labels
df <- df_raw %>% janitor::clean_names()

# Show a small preview
dplyr::glimpse(df)
Rows: 43
Columns: 56
$ consent                                                                                                            <chr> …
$ prior_coding_experience                                                                                            <chr> …
$ frequency_of_ai_use_in_this_course                                                                                 <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_suggesting_r_code_to_solve_problems                                 <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_explaining_r_code_syntax_and_logic                                  <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_improving_code_comments_and_readability                             <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_brainstorming_research_questions_with_neon_metagenomic_data         <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_vibe_code_generating_statistical_network_or_other_advanced_analyses <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_data_wrangling_with_mag_taxonomy_genome_properties_soil_chemistry   <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_understanding_outputs_plots_statistics_model_diagnostics            <chr> …
$ helpfulness_of_generative_ai_for_each_use_case_using_r_studio_via_open_on_demand_on_the_hpc                        <chr> …
$ could_you_give_short_examples_of_a_helpful_ai_response                                                             <chr> …
$ could_you_give_short_examples_of_unhelpful_or_incorrect_ai_responses                                               <chr> …
$ impact_on_learning_ai_made_learning_r_easier                                                                       <chr> …
$ impact_on_learning_ai_helped_me_understand_r_syntax_and_functions                                                  <chr> …
$ impact_on_learning_ai_increased_my_confidence_in_writing_r_code                                                    <chr> …
$ impact_on_learning_ai_helped_me_learn_from_errors_more_efficiently                                                 <chr> …
$ impact_on_learning_ai_encouraged_me_to_try_more_complex_tasks_than_i_would_have_otherwise                          <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_understanding_of_mag_taxonomy                                       <chr> …
$ impact_on_metagenomics_learning_ai_helped_connect_genome_properties_with_soil_chemistry                            <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_ability_to_form_testable_questions_using_neon_data                  <chr> …
$ impact_on_metagenomics_learning_ai_helped_me_interpret_r_outputs_for_metagenomics                                  <chr> …
$ impact_on_metagenomics_learning_ai_improved_my_overall_conceptual_grasp_of_metagenomics                            <chr> …
$ confidence_change_in_programming_in_r                                                                              <chr> …
$ how_much_time_did_using_ai_save_me                                                                                 <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_correct_fewer_errors                                            <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_readable_better_comments_structure                              <chr> …
$ code_quality_outcomes_using_ai_my_code_became_more_efficient_faster_simpler                                        <chr> …
$ code_quality_outcomes_using_ai_my_analyses_became_more_reproducible_clear_steps_scripts                            <chr> …
$ code_quality_outcomes_using_ai_i_relied_on_ai_but_still_validated_results                                          <chr> …
$ frequency_of_incorrect_ai_output                                                                                   <chr> …
$ when_ai_was_wrong_i_typically                                                                                      <chr> …
$ common_issues_encountered                                                                                          <chr> …
$ trust_calibration_i_can_usually_tell_when_ai_is_wrong                                                              <chr> …
$ trust_calibration_i_know_how_to_verify_ai_generated_code                                                           <chr> …
$ trust_calibration_ai_responses_are_transparent_about_uncertainty_limitations                                       <chr> …
$ trust_calibration_ai_sometimes_overstates_confidence_in_its_answers                                                <chr> …
$ ethical_alignment_using_ai_in_this_course_felt_appropriate_and_ethical                                             <chr> …
$ ethical_alignment_clear_guidelines_were_provided_for_ai_use                                                        <chr> …
$ ethical_alignment_ai_use_encouraged_learning_not_shortcuts                                                         <chr> …
$ ethical_alignment_i_understand_when_how_to_credit_ai_assistance                                                    <chr> …
$ did_you_become_more_engaged_or_interactive_in_solving_problems_using_ai                                            <chr> …
$ inquiry_exploration_ai_helped_me_identify_novel_questions_using_neon_geographic_variation                          <chr> …
$ inquiry_exploration_ai_helped_me_connect_ma_gs_to_environmental_gradients                                          <chr> …
$ inquiry_exploration_ai_exposed_me_to_new_analytical_methods                                                        <chr> …
$ inquiry_exploration_ai_helped_me_scope_feasible_workflows_for_our_data                                             <chr> …
$ vibe_code_outcomes_ai_generated_advanced_code_was_runnable_in_our_environment                                      <chr> …
$ vibe_code_outcomes_i_understood_at_least_the_core_idea_of_the_advanced_methods                                     <chr> …
$ vibe_code_outcomes_i_could_critically_evaluate_the_appropriateness_of_those_methods                                <chr> …
$ vibe_code_outcomes_i_would_be_able_to_reproduce_the_analysis_later_with_notes                                      <chr> …
$ clarity_of_instructions_on_ai_use                                                                                  <chr> …
$ where_more_support_would_help                                                                                      <chr> …
$ suggested_changes_for_future_offerings                                                                             <chr> …
$ overall_effectiveness_of_ai_in_this_course                                                                         <dbl> …
$ likelihood_to_recommend_ai_use_in_similar_courses                                                                  <dbl> …
$ final_comments_and_suggestions                                                                                     <chr> …

Likert levels and coercion helper

Modify the level vectors below if your survey uses different exact wording.

R code
# Likert / scale levels (edit to match your exact text if needed)
helpful_levels <- c("Not at all helpful","Slightly helpful","Moderately helpful","Very helpful","Extremely helpful")
agree_levels   <- c("Strongly disagree","Disagree","Neutral","Agree","Strongly agree")
yesno_levels   <- c("No","Yes")
engagement_levels <- c("Much less engaged","Slightly less engaged","No change","Slightly more engaged","Much more engaged")

# Robust coercion helper for character/factor columns:
coerce_likert <- function(vec) {
  u_raw <- as.character(vec)
  u <- stringr::str_trim(u_raw)     # trim whitespace
  # normalize some common variants to canonical forms
  u_norm <- dplyr::case_when(
    u %in% c("Strong disagree") ~ "Strongly disagree",
    u %in% c("Strong agree")    ~ "Strongly agree",
    TRUE ~ u
  )

  # If all values are NA or in helpful_levels -> ordered helpful factor
  if (all(is.na(u_norm) | u_norm %in% helpful_levels)) {
    return(factor(u_norm, levels = helpful_levels, ordered = TRUE))
  }

  # If all values are NA or in agree_levels (including normalized variants) -> ordered agree factor
  if (all(is.na(u_norm) | u_norm %in% agree_levels)) {
    return(factor(u_norm, levels = agree_levels, ordered = TRUE))
  }

  # If all values are NA or in yes/no -> ordered yes/no
  if (all(is.na(u_norm) | u_norm %in% yesno_levels)) {
    return(factor(u_norm, levels = yesno_levels, ordered = TRUE))
  }

  # If all values are NA or in engagement_levels -> ordered engagement
  if (all(is.na(u_norm) | u_norm %in% engagement_levels)) {
    return(factor(u_norm, levels = engagement_levels, ordered = TRUE))
  }

  # If non-missing entries look like integers (e.g., "1","10"), convert to numeric
  u_non_na <- u_norm[!is.na(u_norm)]
  if (length(u_non_na) > 0 && all(stringr::str_detect(u_non_na, "^\\d+$"))) {
    return(as.numeric(u_norm))
  }

  # Fallback: return as (unordered) factor including NA as a level if present
  return(forcats::as_factor(u_norm))
}

Prepare data and infer types

R code
df_plot <- df %>%
  mutate(across(everything(), ~ {
    v <- .
    if (is.numeric(v)) return(v)
    if (is.character(v) || is.factor(v)) return(coerce_likert(v))
    return(v)
  }))

# Use the original (raw) names for nicer labels:
orig_names <- names(df_raw)
clean_names <- names(df)
name_map <- tibble(clean = clean_names, orig = orig_names)

# Summary of inferred types (note: n_distinct uses na.rm; fix from earlier bug)
vars_summary <- tibble(
  column = names(df_plot),
  r_type = map_chr(df_plot, ~ class(.x)[1]),
  unique_values = map_int(df_plot, ~ n_distinct(.x, na.rm = TRUE))
)

knitr::kable(vars_summary, caption = "Inferred types and distinct counts")
Inferred types and distinct counts
column r_type unique_values
consent factor 1
prior_coding_experience factor 5
frequency_of_ai_use_in_this_course factor 4
helpfulness_of_generative_ai_for_each_use_case_suggesting_r_code_to_solve_problems factor 5
helpfulness_of_generative_ai_for_each_use_case_explaining_r_code_syntax_and_logic factor 5
helpfulness_of_generative_ai_for_each_use_case_improving_code_comments_and_readability factor 5
helpfulness_of_generative_ai_for_each_use_case_brainstorming_research_questions_with_neon_metagenomic_data factor 5
helpfulness_of_generative_ai_for_each_use_case_vibe_code_generating_statistical_network_or_other_advanced_analyses ordered 4
helpfulness_of_generative_ai_for_each_use_case_data_wrangling_with_mag_taxonomy_genome_properties_soil_chemistry factor 5
helpfulness_of_generative_ai_for_each_use_case_understanding_outputs_plots_statistics_model_diagnostics factor 5
helpfulness_of_generative_ai_for_each_use_case_using_r_studio_via_open_on_demand_on_the_hpc factor 5
could_you_give_short_examples_of_a_helpful_ai_response factor 41
could_you_give_short_examples_of_unhelpful_or_incorrect_ai_responses factor 41
impact_on_learning_ai_made_learning_r_easier ordered 4
impact_on_learning_ai_helped_me_understand_r_syntax_and_functions factor 5
impact_on_learning_ai_increased_my_confidence_in_writing_r_code ordered 4
impact_on_learning_ai_helped_me_learn_from_errors_more_efficiently ordered 4
impact_on_learning_ai_encouraged_me_to_try_more_complex_tasks_than_i_would_have_otherwise factor 5
impact_on_metagenomics_learning_ai_improved_my_understanding_of_mag_taxonomy ordered 5
impact_on_metagenomics_learning_ai_helped_connect_genome_properties_with_soil_chemistry ordered 5
impact_on_metagenomics_learning_ai_improved_my_ability_to_form_testable_questions_using_neon_data ordered 4
impact_on_metagenomics_learning_ai_helped_me_interpret_r_outputs_for_metagenomics ordered 5
impact_on_metagenomics_learning_ai_improved_my_overall_conceptual_grasp_of_metagenomics ordered 5
confidence_change_in_programming_in_r factor 4
how_much_time_did_using_ai_save_me factor 5
code_quality_outcomes_using_ai_my_code_became_more_correct_fewer_errors ordered 3
code_quality_outcomes_using_ai_my_code_became_more_readable_better_comments_structure ordered 4
code_quality_outcomes_using_ai_my_code_became_more_efficient_faster_simpler ordered 4
code_quality_outcomes_using_ai_my_analyses_became_more_reproducible_clear_steps_scripts ordered 4
code_quality_outcomes_using_ai_i_relied_on_ai_but_still_validated_results ordered 4
frequency_of_incorrect_ai_output factor 4
when_ai_was_wrong_i_typically factor 20
common_issues_encountered factor 21
trust_calibration_i_can_usually_tell_when_ai_is_wrong ordered 4
trust_calibration_i_know_how_to_verify_ai_generated_code ordered 5
trust_calibration_ai_responses_are_transparent_about_uncertainty_limitations ordered 4
trust_calibration_ai_sometimes_overstates_confidence_in_its_answers ordered 4
ethical_alignment_using_ai_in_this_course_felt_appropriate_and_ethical ordered 5
ethical_alignment_clear_guidelines_were_provided_for_ai_use ordered 5
ethical_alignment_ai_use_encouraged_learning_not_shortcuts ordered 4
ethical_alignment_i_understand_when_how_to_credit_ai_assistance ordered 5
did_you_become_more_engaged_or_interactive_in_solving_problems_using_ai ordered 5
inquiry_exploration_ai_helped_me_identify_novel_questions_using_neon_geographic_variation ordered 4
inquiry_exploration_ai_helped_me_connect_ma_gs_to_environmental_gradients ordered 5
inquiry_exploration_ai_exposed_me_to_new_analytical_methods ordered 4
inquiry_exploration_ai_helped_me_scope_feasible_workflows_for_our_data ordered 4
vibe_code_outcomes_ai_generated_advanced_code_was_runnable_in_our_environment ordered 4
vibe_code_outcomes_i_understood_at_least_the_core_idea_of_the_advanced_methods ordered 5
vibe_code_outcomes_i_could_critically_evaluate_the_appropriateness_of_those_methods ordered 4
vibe_code_outcomes_i_would_be_able_to_reproduce_the_analysis_later_with_notes ordered 5
clarity_of_instructions_on_ai_use factor 4
where_more_support_would_help factor 30
suggested_changes_for_future_offerings factor 30
overall_effectiveness_of_ai_in_this_course numeric 5
likelihood_to_recommend_ai_use_in_similar_courses numeric 8
final_comments_and_suggestions factor 31

Helpers: plotting functions

R code
plot_numeric <- function(df, col) {
  col_sym <- rlang::sym(col)
  p_hist <- ggplot(df, aes(x = !!col_sym)) +
    geom_histogram(fill = "#2b8cbe", color = "white", bins = 30, alpha = 0.9) +
    labs(title = col, x = col, y = "Count") +
    theme_minimal()
  p_box <- ggplot(df, aes(y = !!col_sym)) +
    geom_boxplot(fill = "#2b8cbe", alpha = 0.7) +
    labs(x = "", y = col) +
    theme_minimal()
  if (requireNamespace("patchwork", quietly = TRUE)) {
    return(p_hist / p_box + patchwork::plot_layout(heights = c(3, 1)))
  } else {
    return(p_hist)
  }
}

plot_unordered_factor <- function(df, col, top_n = 20) {
  col_sym <- rlang::sym(col)
  tb <- df %>% mutate(tmp = !!col_sym) %>% count(tmp, sort = TRUE, name = "n")
  n_unique <- nrow(tb)
  if (n_unique > top_n) {
    top_vals <- tb %>% slice_max(n, n = top_n) %>% pull(tmp)
    tb2 <- tb %>% mutate(tmp2 = ifelse(tmp %in% top_vals, as.character(tmp), "Other")) %>%
      group_by(tmp2) %>% summarise(n = sum(n), .groups = "drop") %>%
      arrange(n) %>% mutate(tmp2 = forcats::fct_reorder(tmp2, n))
    p <- ggplot(tb2, aes(x = tmp2, y = n, fill = tmp2)) +
      geom_col(show.legend = FALSE) + labs(title = col, x = NULL, y = "Count") +
      theme_minimal() + theme(axis.text.x = element_text(angle = 0, hjust = 0.5))
    return(p)
  } else {
    tb2 <- tb %>% arrange(n) %>% mutate(tmp = forcats::fct_reorder(as.character(tmp), n))
    p <- ggplot(tb2, aes(x = tmp, y = n, fill = tmp)) + geom_col(show.legend = FALSE) +
      labs(title = col, x = NULL, y = "Count") + theme_minimal() +
      theme(axis.text.x = element_text(angle = 0, hjust = 0.5))
    return(p)
  }
}

Group and plot Likert-type (ordered) columns together

This code finds all ordered-factor columns, groups those that share the same level set (and ordering), and produces one horizontal proportional stacked bar chart per group. Each question appears as its own stacked bar with colors for responses. Question labels use the original column names when available.

R code
# find ordered (Likert-like) columns
likert_cols <- names(df_plot)[purrr::map_lgl(df_plot, is.ordered)]
if (length(likert_cols) == 0) {
  cat("No ordered (Likert-like) columns detected.\n")
} else {
  # group by levels signature so columns with same level sets are combined
  signature <- function(f) paste(levels(df_plot[[f]]), collapse = "||")
  groups <- likert_cols %>% split(., map_chr(., signature))

  i <- 1
  for (sig in names(groups)) {
    cols <- groups[[sig]]
    # prepare long table
    long <- df_plot %>%
      select(all_of(cols)) %>%
      pivot_longer(cols = everything(), names_to = "clean_name", values_to = "response") %>%
      mutate(response = factor(response, levels = levels(df_plot[[cols[1]]]), ordered = is.ordered(df_plot[[cols[1]]]))) %>%
      group_by(clean_name, response) %>%
      summarise(n = sum(!is.na(response)), .groups = "drop") %>%
      group_by(clean_name) %>%
      mutate(pct = n / sum(n)) %>%
      ungroup() %>%
      left_join(name_map, by = c("clean_name" = "clean")) %>%
      mutate(orig_label = ifelse(is.na(orig), clean_name, orig))

    # reorder questions by mean/median score so bars have a meaningful order (higher positivity on top)
    # compute a numeric score per response level:
    levs <- levels(df_plot[[cols[1]]])
    score_map <- tibble(response = levs, score = seq_along(levs))
    ordering <- long %>%
      left_join(score_map, by = "response") %>%
      group_by(clean_name, orig_label) %>%
      summarise(mean_score = sum(score * pct), .groups = "drop") %>%
      arrange(mean_score) # lowest to highest

    long <- long %>%
      mutate(orig_label = factor(orig_label, levels = ordering$orig_label))

    # plot: horizontal proportional stacked bar
    p <- ggplot(long, aes(x = orig_label, y = pct, fill = response)) +
      geom_col(position = "fill", color = "white") +
      coord_flip() +
      scale_y_continuous(labels = scales::percent_format()) +
      labs(title = paste0("Likert group ", i, " — questions sharing levels:"),
           subtitle = paste(levs, collapse = " | "),
           x = NULL, y = "Percent", fill = "") +
      theme_minimal() +
      theme(legend.position = "bottom", axis.text.y = element_text(size = 10))

    cat("\n\n## Likert group ", i, "\n\n", sep = "")
    print(p)
    # show a small counts table (top rows)
    counts_tbl <- long %>% select(orig_label, response, n) %>% arrange(orig_label, desc(n))
    print(knitr::kable(head(counts_tbl, 100), caption = paste0("Counts for Likert group ", i, " (by question and response)")))
    i <- i + 1
  }
}

Likert group 1

Counts for Likert group 1 (by question and response)
orig_label response n
Did you become more engaged or interactive in solving problems using AI? Slightly more engaged 23
Did you become more engaged or interactive in solving problems using AI? Slightly less engaged 9
Did you become more engaged or interactive in solving problems using AI? Much more engaged 8
Did you become more engaged or interactive in solving problems using AI? No change 2
Did you become more engaged or interactive in solving problems using AI? Much less engaged 1

Likert group 2

Counts for Likert group 2 (by question and response)
orig_label response n
Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] Extremely helpful 17
Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] Very helpful 14
Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] Moderately helpful 11
Helpfulness of generative AI for each use case [‘Vibe code’: generating statistical, network, or other advanced analyses] Slightly helpful 1

Likert group 3

Counts for Likert group 3 (by question and response)
orig_label response n
Trust calibration [AI responses are transparent about uncertainty/limitations.] Neutral 15
Trust calibration [AI responses are transparent about uncertainty/limitations.] Agree 13
Trust calibration [AI responses are transparent about uncertainty/limitations.] Disagree 12
Trust calibration [AI responses are transparent about uncertainty/limitations.] Strongly disagree 3
“Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] Agree 22
“Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] Neutral 8
“Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] Disagree 6
“Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] Strongly agree 5
“Vibe code” outcomes [I would be able to reproduce the analysis later with notes.] Strongly disagree 2
Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] Agree 16
Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] Neutral 12
Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] Strongly agree 8
Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] Disagree 5
Impact on metagenomics learning [AI improved my understanding of MAG taxonomy.] Strongly disagree 2
Trust calibration [I can usually tell when AI is wrong.] Agree 23
Trust calibration [I can usually tell when AI is wrong.] Neutral 12
Trust calibration [I can usually tell when AI is wrong.] Disagree 5
Trust calibration [I can usually tell when AI is wrong.] Strongly agree 3
Trust calibration [I know how to verify AI-generated code.] Agree 20
Trust calibration [I know how to verify AI-generated code.] Neutral 10
Trust calibration [I know how to verify AI-generated code.] Strongly agree 7
Trust calibration [I know how to verify AI-generated code.] Disagree 5
Trust calibration [I know how to verify AI-generated code.] Strongly disagree 1
Ethical alignment [AI use encouraged learning, not shortcuts.] Agree 16
Ethical alignment [AI use encouraged learning, not shortcuts.] Strongly agree 10
Ethical alignment [AI use encouraged learning, not shortcuts.] Neutral 9
Ethical alignment [AI use encouraged learning, not shortcuts.] Disagree 8
Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] Agree 17
Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] Strongly agree 11
Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] Neutral 9
Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] Strongly disagree 4
Impact on metagenomics learning [AI improved my overall conceptual grasp of metagenomics.] Disagree 2
“Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] Neutral 20
“Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] Agree 11
“Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] Strongly agree 10
“Vibe code” outcomes [I could critically evaluate the appropriateness of those methods.] Disagree 2
Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] Agree 18
Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] Strongly agree 11
Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] Neutral 10
Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] Strongly disagree 2
Impact on metagenomics learning [AI helped connect genome properties with soil chemistry.] Disagree 2
Ethical alignment [Using AI in this course felt appropriate and ethical.] Agree 22
Ethical alignment [Using AI in this course felt appropriate and ethical.] Neutral 10
Ethical alignment [Using AI in this course felt appropriate and ethical.] Strongly agree 9
Ethical alignment [Using AI in this course felt appropriate and ethical.] Strongly disagree 1
Ethical alignment [Using AI in this course felt appropriate and ethical.] Disagree 1
Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] Agree 24
Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] Strongly agree 9
Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] Neutral 6
Inquiry & exploration [AI helped me identify novel questions using NEON geographic variation.] Disagree 4
Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] Agree 24
Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] Strongly agree 11
Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] Neutral 4
Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] Disagree 3
Inquiry & exploration [AI helped me connect MAGs to environmental gradients.] Strongly disagree 1
“Vibe code” outcomes [I understood at least the core idea of the advanced methods.] Agree 16
“Vibe code” outcomes [I understood at least the core idea of the advanced methods.] Strongly agree 15
“Vibe code” outcomes [I understood at least the core idea of the advanced methods.] Neutral 8
“Vibe code” outcomes [I understood at least the core idea of the advanced methods.] Disagree 3
“Vibe code” outcomes [I understood at least the core idea of the advanced methods.] Strongly disagree 1
Code quality outcomes using AI [My code became more efficient (faster/simpler).] Agree 22
Code quality outcomes using AI [My code became more efficient (faster/simpler).] Strongly agree 12
Code quality outcomes using AI [My code became more efficient (faster/simpler).] Neutral 5
Code quality outcomes using AI [My code became more efficient (faster/simpler).] Disagree 4
Ethical alignment [I understand when/how to credit AI assistance.] Agree 25
Ethical alignment [I understand when/how to credit AI assistance.] Strongly agree 11
Ethical alignment [I understand when/how to credit AI assistance.] Disagree 3
Ethical alignment [I understand when/how to credit AI assistance.] Neutral 3
Ethical alignment [I understand when/how to credit AI assistance.] Strongly disagree 1
“Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] Agree 18
“Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] Strongly agree 14
“Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] Neutral 10
“Vibe code” outcomes [AI-generated advanced code was runnable in our environment.] Disagree 1
Ethical alignment [Clear guidelines were provided for AI use.] Strongly agree 17
Ethical alignment [Clear guidelines were provided for AI use.] Agree 16
Ethical alignment [Clear guidelines were provided for AI use.] Neutral 8
Ethical alignment [Clear guidelines were provided for AI use.] Strongly disagree 1
Ethical alignment [Clear guidelines were provided for AI use.] Disagree 1
Impact on learning [AI increased my confidence in writing R code.] Strongly agree 20
Impact on learning [AI increased my confidence in writing R code.] Agree 12
Impact on learning [AI increased my confidence in writing R code.] Neutral 6
Impact on learning [AI increased my confidence in writing R code.] Disagree 5
Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] Agree 16
Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] Strongly agree 16
Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] Neutral 10
Impact on metagenomics learning [AI improved my ability to form testable questions using NEON data.] Disagree 1
Trust calibration [AI sometimes overstates confidence in its answers.] Agree 22
Trust calibration [AI sometimes overstates confidence in its answers.] Strongly agree 13
Trust calibration [AI sometimes overstates confidence in its answers.] Neutral 7
Trust calibration [AI sometimes overstates confidence in its answers.] Disagree 1
Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] Strongly agree 19
Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] Agree 15
Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] Neutral 5
Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] Disagree 3
Impact on metagenomics learning [AI helped me interpret R outputs for metagenomics.] Strongly disagree 1
Code quality outcomes using AI [My code became more readable (better comments, structure).] Agree 20
Code quality outcomes using AI [My code became more readable (better comments, structure).] Strongly agree 15
Code quality outcomes using AI [My code became more readable (better comments, structure).] Neutral 7
Code quality outcomes using AI [My code became more readable (better comments, structure).] Disagree 1
Code quality outcomes using AI [I relied on AI but still validated results.] Agree 20

Plot non-Likert columns individually

R code
other_cols <- setdiff(names(df_plot), likert_cols)

for (col in other_cols) {
  cat("\n\n## ", name_map$orig[name_map$clean == col] %||% col, "\n\n", sep = "")
  col_data <- df_plot[[col]]
  if (is.numeric(col_data)) {
    p <- plot_numeric(df_plot, col)
    print(p)
  } else if (is.factor(col_data)) {
    p <- plot_unordered_factor(df_plot, col)
    print(p)
    tb <- df_plot %>% mutate(val = as.character(!!rlang::sym(col))) %>% count(val, sort = TRUE)
    if (nrow(tb) <= 15) {
      print(knitr::kable(tb, caption = paste("Counts for", col)))
    } else {
      print(knitr::kable(head(tb, 15), caption = paste("Top counts for", col, "(first 15 shown)")))
    }
  } else {
    cat("No standard plot for column type: ", class(col_data)[1], "\n\n")
    print(summary(col_data))
  }
}

Prior coding experience

Counts for prior_coding_experience
val n
None 24
Very limited (a few tutorials or labs) 10
Some (one course or self-study) 6
Extensive (multiple courses or projects) 2
Moderate (regular use in another language) 1

Frequency of AI use in this course

Counts for frequency_of_ai_use_in_this_course
val n
A few times per week 17
Daily 17
About once per week 7
I tried it once or twice 2

Helpfulness of generative AI for each use case [Suggesting R code to solve problems]

Counts for helpfulness_of_generative_ai_for_each_use_case_suggesting_r_code_to_solve_problems
val n
Extremely helpful 26
Very helpful 9
Moderately helpful 5
Slightly helpful 2
Not helpful 1

Helpfulness of generative AI for each use case [Explaining R code syntax and logic]

Counts for helpfulness_of_generative_ai_for_each_use_case_explaining_r_code_syntax_and_logic
val n
Extremely helpful 19
Very helpful 13
Moderately helpful 8
Slightly helpful 2
Not helpful 1

Helpfulness of generative AI for each use case [Improving code comments and readability]

Counts for helpfulness_of_generative_ai_for_each_use_case_improving_code_comments_and_readability
val n
Extremely helpful 18
Very helpful 12
Moderately helpful 7
Not helpful 3
Slightly helpful 3

Helpfulness of generative AI for each use case [Brainstorming research questions with NEON metagenomic data]

Counts for helpfulness_of_generative_ai_for_each_use_case_brainstorming_research_questions_with_neon_metagenomic_data
val n
Very helpful 17
Extremely helpful 16
Moderately helpful 7
Slightly helpful 2
Not helpful 1

Helpfulness of generative AI for each use case [Data wrangling with MAG taxonomy + genome properties + soil chemistry]

Counts for helpfulness_of_generative_ai_for_each_use_case_data_wrangling_with_mag_taxonomy_genome_properties_soil_chemistry
val n
Extremely helpful 15
Very helpful 13
Moderately helpful 7
Slightly helpful 6
Not helpful 2

Helpfulness of generative AI for each use case [Understanding outputs (plots, statistics, model diagnostics)]

Counts for helpfulness_of_generative_ai_for_each_use_case_understanding_outputs_plots_statistics_model_diagnostics
val n
Very helpful 18
Extremely helpful 11
Moderately helpful 9
Slightly helpful 3
Not helpful 2

Helpfulness of generative AI for each use case [Using RStudio via OpenOnDemand on the HPC]

Counts for helpfulness_of_generative_ai_for_each_use_case_using_r_studio_via_open_on_demand_on_the_hpc
val n
Very helpful 13
Moderately helpful 12
Extremely helpful 9
Slightly helpful 6
Not helpful 3

Could you give short examples of a helpful AI response

Top counts for could_you_give_short_examples_of_a_helpful_ai_response (first 15 shown)
val n
NA 2
-producing helpful explanations when codes do not run, providing simple code fixes 1
A lot of the time I asked AI to help explain certain coding functions or I would ask them why I am getting the error message I am getting when rendering my lab and that’s helped me learn from why I can’t write the code in certain ways. So AI has definitely helped me improve my coding syntax so that less errors come up when I render my labs. 1
AI can help clean out a code chunk by replacing verbose patterns with simpler, more readable alternatives — for example, instead of writing filter(!is.na(site_id), !is.na(phylum)) %>% count(site_id, phylum), AI might suggest drop_na(site_id, phylum) %>% count(site_id, phylum), which is shorter and easier to understand. 1
AI fixing errors in my code 1
AI has been helpful in providing responses to fix my coding errors. For example, I would tell CoPilot the code I was trying to run, and say it was not working and enter the specific “Error:…” I was getting. Copilot would then send back the correct code (most of the time), and explain where I went wrong which was really helpful so that I would not make the same mistake again. 1
AI was able to come up analyses and graphs for the data that I never would have thought of. It also provided the code for each analysis which was very helpful when trying to reproduce the graph in RStudio. 1
AI was very good at telling me what an error message meant, provided that I gave them the exact error message R was giving me. AI would often explain what the error message meant and then provide multiple common ways to solve this problem. 1
All of the assignments like Making a graph for neon image data 1
Anything I don’t know ai can help 1
Before we learned the definitions of regex patterns and I tried to ask AI to create patterns for effective character finding, I used AI to give an explanation of the reasoning and meaning of the regex patterns it generated. Even before we formally learned the skill, AI helped me think of advanced regex patterns. 1
Giving an example of the code and then explainging what each part does, making it easy to know what use/add to get the product i needed 1
Giving me different types of analysis I could do to see spatial autocorrelation for the MAG and metadata dataset 1
Having an idea on how you want data to be analyzed but not being sure of what kind of graphic would be best suited for that. AI can suggest a few different methods and write the bulk of the code required to set the graphic up in RStudio. 1
Here’s a specific example: my question to AI was: “what’s the difference between your solution and what I wrote?” AI gave me a step by step explanation of (1) what my code does and (2) problems my code causes (failing to address the problem). The specific problem I was working on was How to display a table that counts the number of MAGs by phylum at each site. AI was very helpful in all circumstances, especially in Suggesting R code to solve problems and Explaining R code syntax and logic. Those were my two top uses of AI. Of course, AI helped with all the other categories too, but for the most part, the two I just mentioned were the categories that I most often consulted AI for. I feel like the category Data wrangling with MAG taxonomy + genome properties + soil chemistry can be included underneath either of these two, because it was related to problem-solving. The reason I put Extremely helpful for all categories because of the ability to consult AI for really almost everything. For the two categories I mentioned above, these are the prompts I would ask “Here’s my code. It seems to me that it works fine, but can you verify that it really does?” Or, “What does this function do? What’s the difference between this one and this one?” Or, “Here’s the problem I’m trying to solve, and here’s my code so far. Can you help me with my code (either troubleshoot this error I’m getting or show me whether this is the best way to approach the problem)”. I took advantage of making the most out of AI by asking it to explain functions it used that I wasn’t familiar with. I also always tried to understand AI logic by walking myself through each line, one by one. The next two categories that I used AI for mostly in this course was Brainstorming research questions with NEON metagenomic data. ‘Vibe code’: generating statistical, network, or other advanced analyses kind of follows or falls under this. This is especially helpful because I don’t have a research background and while I can ask simple questions like “What phyla are enriched in these soil pH ranges?”, I still would need to expand on this question. My problem is that I’m not creative (maybe not curious enough?) with my questions. This is why using AI to jumpstart brainstorming is especially helpful, especially because it can quickly provide background information that might spark my curiosity. 1

Could you give short examples of unhelpful or incorrect AI responses

Top counts for could_you_give_short_examples_of_unhelpful_or_incorrect_ai_responses (first 15 shown)
val n
NA 2
AI going in the wrong direction about my code 1
AI is very prompt-specific, so if a prompt does not reflect exactly what the person wants, it takes a lot of back and forth between the AI and the person to get a good result. 1
AI isnt the best at helping with MAG data or anything in terms of troubleshooting for working directory 1
AI made some graphs that were not accurate or did not have a good set up. Also certain commands it was not good at using. 1
AI responses that don’t provide a code or give super complicated unrunnable codes 1
AI telling me to install and load new libraries when I don’t even need them. 1
An unhelpful AI response might be overly vague, like ‘Just fix the code somehow’, which gives no actionable guidance. Another incorrect response could confidently suggest a function or method that doesn’t exist, leaving the user confused and misled. 1
For me, examples would be when the code simply doesn’t work. Sometimes it’s due to base R issues or packages and version incompatibility—things like that. I don’t know any technical terms to describe what the issues are more specifically. I also don’t have a good understanding of how computers work. One specific example is when I wanted to do an analysis of MAG data using a heat map based on soil moisture. My input was, “Here’s my code so far where I got the average soil temperature for each phyla. How do I make a heat map from here?” AI gave me a solution where I had to convert my data frame to a matrix first. The code didn’t work from there due to some issues with creating the matrix. I believe I could have troubleshooted some more, as well as learn more about matrices on my own, but in that moment I really just wanted a quick visual and wasn’t willing to spend time to learn about matrices. I think the only issue with AI feedback here is that my code is nuanced to the data I’m working with and AI doesn’t get to have the full picture. I admit I could have been less lazy here and try troubleshooting it myself! 1
For some of the more complicated data analysis there will be some lines where you get an error and try to use AI to solve it. However it can’t solve it (maybe due to package/R version incompatibility) and you end up going down a rabbit hole and wasting time. 1
Hardest to solve problems. If something did not work or wrong answer, needed to figure it out mostly on my own, AI hardly could fix it. 1
I found that some of the unhelpful/incorrect Ai responses typically had to do with sometimes I felt like it did not listen to my requests or it would suggest troubleshooting techniques that would not work. 1
I was trying to join two data sets but the IDs in the data sets had slightly different suffixes. The suggestion that AI was giving me wasn’t working in removing the suffix but it kept going around in the same circle. Eventually, AI was able to make the join work but I am not sure how… 1
If I used AI to generate new code, it would often assume file/column names. When I input my edited code (with corrected file and column names), it would solve problems in the code but still using the file names it originally created. Not a terrible issue, just annoying 1
In lab S3 Connecting a Github repo site with a new RStudio project. It kept giving me wrong code to link and due to that the Lab was not loading 1

Impact on learning [AI helped me understand R syntax and functions.]

Counts for impact_on_learning_ai_helped_me_understand_r_syntax_and_functions
val n
Strongly agree 19
Agree 12
Neutral 6
Disagree 5
Stongly disagree 1

Impact on learning [AI encouraged me to try more complex tasks than I would have otherwise.]

Counts for impact_on_learning_ai_encouraged_me_to_try_more_complex_tasks_than_i_would_have_otherwise
val n
Strongly agree 24
Agree 11
Neutral 5
Disagree 2
Stongly disagree 1

Confidence change in programming in R

Counts for confidence_change_in_programming_in_r
val n
Higher 30
Much higher 7
About the same 5
Much lower 1

How much time did using AI save me

Counts for how_much_time_did_using_ai_save_me
val n
3+ hrs 21
2-3 hrs 12
1-2 hrs 8
0.5-1 hrs 1
< 0.5 hr total 1

Frequency of incorrect AI output

Counts for frequency_of_incorrect_ai_output
val n
Sometimes 28
Often 10
Rarely 3
Very Often 1
NA 1

When AI was wrong, I typically…

Top counts for when_ai_was_wrong_i_typically (first 15 shown)
val n
Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI 6
Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor 6
Ran and tested the code in R, Asked follow-up questions to the AI 4
Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates 3
Ran and tested the code in R, Checked documentation or help pages, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor, Ignored or discarded AI suggestions 3
Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor 2
Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor 2
Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Consulted the instructor, Ignored or discarded AI suggestions 2
Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates, Ignored or discarded AI suggestions 2
Ran and tested the code in R, Asked follow-up questions to the AI, Consulted the instructor, Ignored or discarded AI suggestions 2
Ran and tested the code in R, Asked follow-up questions to the AI, Ignored or discarded AI suggestions 2
Asked follow-up questions to the AI 1
Asked follow-up questions to the AI, Consulted classmates, Ignored or discarded AI suggestions 1
Checked documentation or help pages 1
Ran and tested the code in R, Asked follow-up questions to the AI, Consulted classmates 1

Common issues encountered

Top counts for common_issues_encountered (first 15 shown)
val n
Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data 10
Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data 4
Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions 3
Hallucinated functions or packages, Misinterpretation of MAG/soil data 3
Misinterpretation of MAG/soil data, Confident but unsupported claims 3
Incorrect R syntax or arguments, Misinterpretation of MAG/soil data 2
Incorrect R syntax or arguments, Overcomplicated solutions, Confident but unsupported claims 2
Misinterpretation of MAG/soil data 2
Overcomplicated solutions, Misinterpretation of MAG/soil data 2
Hallucinated functions or packages, Incorrect R syntax or arguments, Misinterpretation of MAG/soil data 1
Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims, Ethical concerns 1
Hallucinated functions or packages, Incorrect R syntax or arguments, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims, sometimes, he is just a little dumb 1
Hallucinated functions or packages, Overcomplicated solutions 1
Hallucinated functions or packages, Overcomplicated solutions, Misinterpretation of MAG/soil data, Confident but unsupported claims 1
Incorrect R syntax or arguments 1

Clarity of instructions on AI use

Counts for clarity_of_instructions_on_ai_use
val n
Clear 27
Very clear 12
Neutral 3
Unclear 1

Where more support would help

Top counts for where_more_support_would_help (first 15 shown)
val n
Debugging with AI, Verifying AI output, Advanced analyses 3
Prompting strategies, Debugging with AI, Verifying AI output, Integrating AI with R 3
Verifying AI output 3
Debugging with AI, Integrating AI with R, Advanced analyses 2
Debugging with AI, Verifying AI output, Ethics & citation, Advanced analyses 2
Ethics & citation 2
Prompting strategies, Debugging with AI 2
Prompting strategies, Debugging with AI, Integrating AI with R 2
Prompting strategies, Debugging with AI, Verifying AI output 2
Prompting strategies, Verifying AI output, Ethics & citation 2
Debugging with AI, Ethics & citation 1
Debugging with AI, Verifying AI output 1
Debugging with AI, Verifying AI output, Ethics & citation 1
Debugging with AI, Verifying AI output, Ethics & citation, Integrating AI with R 1
Debugging with AI, Verifying AI output, Integrating AI with R, Advanced analyses 1

Suggested changes for future offerings

Top counts for suggested_changes_for_future_offerings (first 15 shown)
val n
NA 12
N/A 2
AI skyrocketed my coding capabilities. However, I don’t feel very confident in coding without AI. This class would benefit from spending more time on ingraining R/coding basics before moving to advanced R coding and metagenomic analysis. Maybe the first half of the course could be ingraining both the basics in code and metagenomic analysis and the second half could be the explosive, exciting, AI based coding and analysis. Using AI was a world-opening experience for me in coding. 1
Ask people to discuss there code, or allow for people to do independent projects. I really enjoyed the last lab that was open ended. If we did the end of year project I think that I would have been able to utilize all the skills that I learned. 1
Covering more on ethics and AI use 1
Have a class specifically for how to ask copilot for help with R coding, including how to write a helpful prompt and dissect the answers so that you are able to use them in your actual code. 1
I definitely think that lab reports should require students to report the prompt that was used to generate any code they used, preceding an exercise. I think this is important data for this class and can be used to think of effective prompting strategies.

One idea I had, is to use Monday discussions to do either class-wide or team/table debriefing in which we talk about what sort of code we are getting from AI. I think a collaborative aspect in this class would be helpful for keeping students on track together. | 1| |I feel like Debugging with AI is the most common issue I experience when using AI for code because what we are working on can be so nuanced. Because of the nuance, I’m not sure how feasible in-class support with AI debugging would be (in the context of a whole class period), especially if everyone is working on different analyses / project? I would say the same thing for Verifying AI output. I think AI is a useful tool used for assistance, but I also found that what we did in the course has been very valuable— namely doing the chapter outlines. They can take quite a while to get through, but I agree that it’s important for us to know the basics of R ourselves.

For Advanced analyses, maybe it would be helpful to have a brief overview in class of things like alpha-diversity and beta-diversity. I learned about this before in other classes (and don’t remember what they are), so maybe formally going over it in class, if only briefly, would be good. Maybe taking an additional lecture to explain more of what MAGs are and why they’re useful in research, since I didn’t get it the first time. Eventually I came to understand what they are. Also, personally I don’t know anything about analyzing data, so if we received some advice about things to pay attention to (for example, make sure you take a larger sample size. Or any research principles we aren’t aware of? And what is ANOVA test, if we happened to need to use it) from class, just briefly, that would help. As for using AI to help generate code for Advanced analyses, it helped so much.

Perhaps one thing I think would be good for this course is to require or at least highly encourage students to explain what their code chunk does, and put that explanation in the Quarto document above the code chunk. Or to put comments in code in cases where the code looks suspiciously flawless. We sometimes do these things by putting the header “AI note” and “Code chunk”, but I wonder whether it would be good for students to go further than minimally stating what prompt they asked AI. Either way, I suppose a student’s ability to gain some useful knowledge is up to how disciplined they are able to be when they have powerful resources like AI. | 1| |I had hoped that the class would be more focused on the NEON Lab data and allow more time to work with it. We only engaged with the dataset for the last 2 weeks of classes. And while the previous R sessions did build foundational skills that definitely helped in analyzing the NEON Lab data, it would have been more beneficial to introduce and work with the data earlier during the course. Because for me, doing so could have helped with better understanding the value of using coding tools for biological data. | 1| |I know students will use Al to help them in this course in one way or another but if there’s a way to help improve learning. I know many of us had no background use of coding at all and we kind of jumped in quickly so I would depend on Al a lot to simply just get my work done. | 1| |I think AI helped my learning expirence I would just add more to debugging and varifying AI like how to maybe do a monday class on this instead of a lab. | 1| |I think because there is a Monday and Wednesday portion, The Monday portion should be spent explaining what the lab on Wednesday will be. I found myself using AI a lot for things that I felt could’ve been discussed in class. | 1| |I think it was sometimes confusing to know exactly how to cite AI in the course, so more clarity on when/how it should be used in the earlier labs would be helpful. | 1| |I think it’s like a calculator, I would not use it for anything else. It works less well than google for research, but it works as expected when given complex prompts. You may need to amen/check the equation yourself for sure, but it will be able to give you a decent starting point/do the easy stuff faster than you. | 1| |I think when starting with AI sometimes it’s easy to just copy and paste the question we’re asked, but I think it would be helpful to start off with examples of how we can prompt AI to guide us in answering our problems. | 1|

Overall effectiveness of AI in this course

Likelihood to recommend AI use in similar courses

Final comments and suggestions

Top counts for final_comments_and_suggestions (first 15 shown)
val n
NA 12
AI helped me understand and learn a lot more in this course than I could have otherwise without it! 1
AI really helped understanding the coding. 1
AI removes the need to spend hours learning coding and allows me to focus on more important things 1
Ai really did help and I feel like it is needed for advanced code based on the level of most students in this class, it just made it so coding felt robotic and I learned a little less. 1
Good course to introduce someone to the use of AI in R, but would have been helpful/interesting to learn some of the basics beforehand. 1
I enjoyed this class and performed analyses I never would have thought of without AI suggestions. I would have liked to learn coding without AI first to establish a foundation, but ultimately, using AI allowed me to complete a lot more work and understand more functions in R code. 1
I feel like the effectiveness of AI in this course varies between students, so this survey is very interesting! I could see AI inhibiting learning if students used it heavily in the beginning of the course when we focused on R basics, because then that work is just busy work. I feel like I learned the most from the beginning of the course just using AI as an occasional troubleshooting tool, but depending on AI from the start would have been detrimental. 1
I genuinely think the point of AI is like computers and calculators, make complex work easier. I just think we should not confuse a glorified calculator with a friend, God’s word, or an actual intelligent person (Cogito, ergo sum).

Even if it was an intelligent person, I would check their words and answers if I suspected it sounded too good to be true (that’s probably because by nature, I also have a tendency to say things with a lot of confidence even if they are not true—simply because I believe them). If someone came to me with the total confidence that there are three types of T cells, I would know better and tell them “that’s not true.” If they told me “a new type of IgG was discovered in a paper by Matt et al,” I’d have a tendency to say “yes? Can you show me?.” If I was told “Did you know there are over 300 types of turtles?” I may have a small doubt, but usually say “oh nice!” and accept it as a doubtful, but actual fact (and mess up and repeat it with total confidence to other people as a truth). Asking any question to AI comes with the understanding that it is only a computer and just does math. But even if it could think and was human, wouldn’t we also double-check their statement and thoughts? Or correct them, or ask for proofs? | 1| |I liked being able to use AI but I wish I knew what to do if I fall down a rabbit hole of incorrect codes with CoPilot. | 1| |I really did enjoy the course overall, I like the room and set up of working with a group. I think Dr. Blanchard was helpful when I went to office hours or needed help in class. I wish we learned a few more basic coding steps because I think I relied on AI too much. I still think it should be a big part of the course but just that a little more coding without it at the start | 1| |I think AI has its place in the modern world but that place is not everywhere. I understand the potential AI has for making coding more accessible for newcomers but it should not eliminate the learning process. A balance needs to be found between AI use and organic learning. | 1| |I think the integration of AI is helpful in beginner courses as sometimes AI has a good way to “dumb” things down almost to explain why the code produces the output that it does. Sometimes having a conversation with AI helps the learner understand a lot more than just reading the textbook because sometimes we need more examples than just the ones provided to see what the concept is trying to show us. | 1| |I wish there was less of a need to use AI in this course, but once things started getting complicated it was very hard to do anything without the use of AI, especially considering most of us in the class had no experience with coding of any sort. For example, I did not use AI for the first couple of labs, and that was on purpose because I did not want to have to rely on AI for everything I did. The first couple of labs were manageable to do without the use of AI, and they were just challenging enough where I was actually learning a lot of the basics of coding. However, after a certain point, I felt I needed to use AI to get the work done because the level of difficulty increased too much for me to figure out the coding on my own. After that point, I relied on AI too much, and I wasn’t learning anymore. | 1| |I would not have been able to complete this class without the assistance of AI and if you want to continue to have a large workload AI is 100% necessary and is helpful. It is more on the individual student themselves to actually make sure we learn the content rather than just copy and pasting. | 1|

Notes and customization

  • Columns are grouped only if their factor level sets (and order) are identical. If you prefer to force all ordered columns into a single plot even if their levels differ, I can change the code to align/standardize levels first (mapping to a canonical scale).
  • If you want diverging stacked bars centered on “Neutral” (for Agree/Disagree scales), I can add a specialized diverging plot function.
  • If some Likert questions need manual re-labeling or grouping (e.g., put related questions together), tell me which clean or original column names to group and I will alter the layout.

If you’d like, I can also run this on your CSV and attach the resulting HTML (upload the CSV here), or paste a small tweak to center scales on Neutral.